home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / emacs / emacs1857 / src_d2.zoo / source / indent.c < prev    next >
C/C++ Source or Header  |  1991-12-09  |  17KB  |  629 lines
  1. /* Indentation functions.
  2.    Copyright (C) 1985, 1986, 1987, 1988, 1990 Free Software Foundation, Inc.
  3.  
  4. This file is part of GNU Emacs.
  5.  
  6. GNU Emacs is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. GNU Emacs is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU Emacs; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20.  
  21. #include "config.h"
  22. #include "lisp.h"
  23. #include "buffer.h"
  24. #include "indent.h"
  25. #include "window.h"
  26. #include "termchar.h"
  27. #include "termopts.h"
  28.  
  29. #define CR '\015'
  30.  
  31. /* Indentation can insert tabs if this is non-zero;
  32.    otherwise always uses spaces */
  33. int indent_tabs_mode;
  34.  
  35. #define min(a, b) ((a) < (b) ? (a) : (b))
  36. #define max(a, b) ((a) > (b) ? (a) : (b))
  37.  
  38. /* These three values memoize the current column to avoid recalculation */
  39. /* Some things in set last_known_column_point to -1
  40.   to mark the memoized value as invalid */
  41. /* Last value returned by current_column */
  42. int last_known_column;
  43. /* Value of point when current_column was called */
  44. int last_known_column_point;
  45. /* Value of MODIFF when current_column was called */
  46. int last_known_column_modified;
  47.  
  48. extern int minibuf_prompt_width;
  49.  
  50. DEFUN ("current-column", Fcurrent_column, Scurrent_column, 0, 0, 0,
  51.   "Return the horizontal position of point.  Beginning of line is column 0.\n\
  52. This is calculated by adding together the widths of all the displayed\n\
  53. representations of the character between the start of the previous line\n\
  54. and point.  (eg control characters will have a width of 2 or 4, tabs\n\
  55. will have a variable width)\n\
  56. Ignores finite width of screen, which means that this function may return\n\
  57. values greater than (screen-width).\n\
  58. Whether the line is visible (if `selective-display' is t) has no effect.")
  59.   ()
  60. {
  61.   Lisp_Object temp;
  62.   XFASTINT (temp) = current_column ();
  63.   return temp;
  64. }
  65.  
  66. int
  67. current_column ()
  68. {
  69.   register int col;
  70.   register unsigned char *ptr, *stop, c;
  71.   register int tab_seen;
  72.   register int post_tab;
  73.   register int tab_width = XINT (current_buffer->tab_width);
  74.   int ctl_arrow = (!NULL (current_buffer->ctl_arrow))
  75.                   + (EQ (current_buffer->ctl_arrow, Qt));
  76.  
  77.   if (point == last_known_column_point
  78.       && MODIFF == last_known_column_modified)
  79.     return last_known_column;
  80.  
  81.   /* Make a pointer for decrementing through the chars before point.  */
  82.   ptr = &FETCH_CHAR (point - 1) + 1;
  83.   /* Make a pointer to where consecutive chars leave off,
  84.      going backwards from point.  */
  85.   if (point == BEGV)
  86.     stop = ptr;
  87.   else if (point <= GPT || BEGV > GPT)
  88.     stop = BEGV_ADDR;
  89.   else
  90.     stop = GAP_END_ADDR;
  91.  
  92.   if (tab_width <= 0 || tab_width > 20) tab_width = 8;
  93.  
  94.   col = 0, tab_seen = 0, post_tab = 0;
  95.  
  96.   while (1)
  97.     {
  98.       if (ptr == stop)
  99.     {
  100.       /* We stopped either for the beginning of the buffer
  101.          or for the gap.  */
  102.       if (ptr == BEGV_ADDR)
  103.         break;
  104.       /* It was the gap.  Jump back over it.  */
  105.       stop = BEGV_ADDR;
  106.       ptr = GPT_ADDR;
  107.       /* Check whether that brings us to beginning of buffer.  */
  108.       if (BEGV >= GPT) break;
  109.     }
  110.  
  111.       c = *--ptr;
  112.       if (c >= 040 && c < 0177)
  113.     {
  114.       col++;
  115.     }
  116.       else if (c == '\n')
  117.     break;
  118.       else if (c == '\r' && EQ (current_buffer->selective_display, Qt))
  119.     break;
  120.       else if (c == '\t')
  121.     {
  122.       if (tab_seen)
  123.         col = ((col + tab_width) / tab_width) * tab_width;
  124.  
  125.       post_tab += col;
  126.       col = 0;
  127.       tab_seen = 1;
  128.     }
  129.       else
  130.       col += (ctl_arrow == 1 && c >= 0177) ? 1 :
  131.                (ctl_arrow && c < 0200) ? 2 : 4;
  132.     }
  133.  
  134.   if (tab_seen)
  135.     {
  136.       col = ((col + tab_width) / tab_width) * tab_width;
  137.       col += post_tab;
  138.     }
  139.  
  140.   last_known_column = col;
  141.   last_known_column_point = point;
  142.   last_known_column_modified = MODIFF;
  143.  
  144.   return col;
  145. }
  146.  
  147. ToCol (col)
  148.      int col;
  149. {
  150.   register int fromcol = current_column ();
  151.   register int n;
  152.   register int tab_width = XINT (current_buffer->tab_width);
  153.  
  154.   if (fromcol > col)
  155.     return;
  156.  
  157.   if (tab_width <= 0 || tab_width > 20) tab_width = 8;
  158.  
  159.   if (indent_tabs_mode)
  160.     {
  161.       n = col / tab_width - fromcol / tab_width;
  162.       if (n)
  163.     {
  164.       while (n-- > 0)
  165.         insert ("\t", 1);
  166.  
  167.       fromcol = (col / tab_width) * tab_width;
  168.     }
  169.     }
  170.  
  171.   while (fromcol < col)
  172.     {
  173.       insert ("        ", min (8, col - fromcol));
  174.       fromcol += min (8, col - fromcol);
  175.     }
  176.  
  177.   last_known_column = col;
  178.   last_known_column_point = point;
  179.   last_known_column_modified = MODIFF;
  180. }
  181.  
  182. DEFUN ("indent-to", Findent_to, Sindent_to, 1, 2, "NIndent to column: ",
  183.   "Indent from point with tabs and spaces until COLUMN is reached.\n\
  184. Always do at least MIN spaces even if that goes past COLUMN;\n\
  185. by default, MIN is zero.")
  186.   (col, minimum)
  187.      Lisp_Object col, minimum;
  188. {
  189.   int mincol;
  190.   register int fromcol;
  191.   register int tab_width = XINT (current_buffer->tab_width);
  192.  
  193.   CHECK_NUMBER (col, 0);
  194.   if (NULL (minimum))
  195.     XFASTINT (minimum) = 0;
  196.   CHECK_NUMBER (minimum, 1);
  197.  
  198.   fromcol = current_column ();
  199.   mincol = fromcol + XINT (minimum);
  200.   if (mincol < XINT (col)) mincol = XINT (col);
  201.  
  202.   if (fromcol == mincol)
  203.     return make_number (fromcol);
  204.  
  205.   if (tab_width <= 0 || tab_width > 20) tab_width = 8;
  206.  
  207.   if (indent_tabs_mode)
  208.     {
  209.       Lisp_Object n;
  210.       XFASTINT (n) = mincol / tab_width - fromcol / tab_width;
  211.       if (XFASTINT (n) != 0)
  212.     {
  213.       Finsert_char (make_number ('\t'), n);
  214.  
  215.       fromcol = (mincol / tab_width) * tab_width;
  216.     }
  217.     }
  218.  
  219.   XFASTINT (col) = mincol - fromcol;
  220.   Finsert_char (make_number (' '), col);
  221.  
  222.   last_known_column = mincol;
  223.   last_known_column_point = point;
  224.   last_known_column_modified = MODIFF;
  225.  
  226.   XSETINT (col, mincol);
  227.   return col;
  228. }
  229.  
  230. DEFUN ("current-indentation", Fcurrent_indentation, Scurrent_indentation,
  231.   0, 0, 0,
  232.   "Return the indentation of the current line.\n\
  233. This is the horizontal position of the character\n\
  234. following any initial whitespace.")
  235.   ()
  236. {
  237.   Lisp_Object val;
  238.  
  239.   XFASTINT (val) = position_indentation (find_next_newline (point, -1));
  240.   return val;
  241. }
  242.  
  243. position_indentation (pos)
  244.      register int pos;
  245. {
  246.   register int column = 0;
  247.   register int tab_width = XINT (current_buffer->tab_width);
  248.   register unsigned char *p;
  249.   register unsigned char *stop;
  250.  
  251.   if (tab_width <= 0 || tab_width > 20) tab_width = 8;
  252.  
  253.   stop = &FETCH_CHAR (BufferSafeCeiling (pos)) + 1;
  254.   p = &FETCH_CHAR (pos);
  255.   while (1)
  256.     {
  257.       while (p == stop)
  258.     {
  259.       if (pos == ZV)
  260.         return column;
  261.       pos += p - &FETCH_CHAR (pos);
  262.       p = &FETCH_CHAR (pos);
  263.       stop = &FETCH_CHAR (BufferSafeCeiling (pos)) + 1;
  264.     }
  265.       switch (*p++)
  266.     {
  267.     case ' ':
  268.       column++;
  269.       break;
  270.     case '\t':
  271.       column += tab_width - column % tab_width;
  272.       break;
  273.     default:
  274.       return column;
  275.     }
  276.     }
  277. }
  278.  
  279. DEFUN ("move-to-column", Fmove_to_column, Smove_to_column, 1, 1, 0,
  280.   "Move point to column COLUMN in the current line.\n\
  281. COLUMN is calculated by adding together the widths of all the displayed\n\
  282. representations of the character between the start of the previous line\n\
  283. and point.  (eg control characters will have a width of 2 or 4, tabs\n\
  284. will have a variable width)\n\
  285. Ignores finite width of screen, which means that this function may be\n\
  286. passed values greater than (screen-width)")
  287.   (column)
  288.      Lisp_Object column;
  289. {
  290.   register int pos = point;
  291.   register int col = current_column ();
  292.   register int goal;
  293.   register int end = ZV;
  294.   register int tab_width = XINT (current_buffer->tab_width);
  295.   register int ctl_arrow = (!NULL (current_buffer->ctl_arrow))
  296.                          + (EQ (current_buffer->ctl_arrow, Qt));
  297.  
  298.   Lisp_Object val;
  299.  
  300.   if (tab_width <= 0 || tab_width > 20) tab_width = 8;
  301.   CHECK_NUMBER (column, 0);
  302.   goal = XINT (column);
  303.   if (col > goal)
  304.     {
  305.       pos = find_next_newline (pos, -1);
  306.       col = 0;
  307.     }
  308.  
  309.   while (col < goal && pos < end)
  310.     {
  311.       int c = FETCH_CHAR (pos);
  312.       if (c == '\n')
  313.     break